#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
TTS 管理器
统一管理 HTTP 和 WebSocket 两种 TTS 客户端
"""

import os
from typing import Optional, Union
from dotenv import load_dotenv
from .tts_client import TTSClient
from .tts_websocket_client import TTSWebSocketClient

# 加载环境变量
load_dotenv()


class TTSManager:
    """TTS 管理器类"""
    
    def __init__(self, client_type: Optional[str] = None):
        """
        初始化 TTS 管理器
        
        Args:
            client_type: 客户端类型 ('http', 'websocket', 'auto')
                        如果为 None 或 'auto'，将根据环境变量自动选择
        """
        self.client_type = client_type or os.getenv('TTS_CLIENT_TYPE', 'auto')
        self.client: Union[TTSClient, TTSWebSocketClient, None] = None
        self._initialize_client()
    
    def _initialize_client(self):
        """
        根据配置初始化相应的 TTS 客户端
        """
        if self.client_type == 'websocket':
            self.client = TTSWebSocketClient()
            print("🔊 使用 WebSocket TTS 客户端")
        elif self.client_type == 'http':
            self.client = TTSClient()
            print("🔊 使用 HTTP TTS 客户端")
        elif self.client_type == 'auto':
            # 自动选择：优先使用 WebSocket，如果配置不完整则回退到 HTTP
            try:
                ws_client = TTSWebSocketClient()
                if ws_client.validate_config():
                    self.client = ws_client
                    self.client_type = 'websocket'
                    print("🔊 自动选择 WebSocket TTS 客户端")
                else:
                    raise ValueError("WebSocket TTS 配置不完整")
            except Exception as e:
                print(f"⚠️ WebSocket TTS 初始化失败，回退到 HTTP TTS: {e}")
                try:
                    self.client = TTSClient()
                    self.client_type = 'http'
                    print("🔊 使用 HTTP TTS 客户端")
                except Exception as http_error:
                    raise RuntimeError(f"所有 TTS 客户端初始化失败: HTTP={http_error}, WebSocket={e}")
        else:
            raise ValueError(f"不支持的 TTS 客户端类型: {self.client_type}")
    
    def synthesize(self, text: str, output_file: Optional[str] = None, **kwargs) -> bytes:
        """
        同步合成语音
        
        Args:
            text: 要合成的文本
            output_file: 输出文件路径（可选）
            **kwargs: 其他参数
            
        Returns:
            音频数据（bytes）
        """
        if not self.client:
            raise RuntimeError("TTS 客户端未初始化")
        
        return self.client.synthesize(text, output_file=output_file, **kwargs)
    
    async def synthesize_async(self, text: str, output_file: Optional[str] = None, **kwargs) -> bytes:
        """
        异步合成语音
        
        Args:
            text: 要合成的文本
            output_file: 输出文件路径（可选）
            **kwargs: 其他参数
            
        Returns:
            音频数据（bytes）
        """
        if not self.client:
            raise RuntimeError("TTS 客户端未初始化")
        
        return await self.client.synthesize_async(text, output_file=output_file, **kwargs)
    
    async def cancel_synthesis(self):
        """
        取消当前正在进行的语音合成
        
        注意：只有 WebSocket 客户端支持取消功能
        """
        if not self.client:
            raise RuntimeError("TTS 客户端未初始化")
        
        if hasattr(self.client, 'cancel_synthesis'):
            await self.client.cancel_synthesis()
        else:
            print(f"⚠️ 当前 TTS 客户端类型 ({self.client_type}) 不支持取消功能")
    
    def reset_cancel_flag(self):
        """
        重置取消标志
        
        注意：只有 WebSocket 客户端支持此功能
        """
        if not self.client:
            return
        
        if hasattr(self.client, 'reset_cancel_flag'):
            self.client.reset_cancel_flag()
    
    def get_available_speakers(self) -> list:
        """
        获取可用的音色列表
        
        Returns:
            音色列表
        """
        if not self.client:
            return []
        
        return self.client.get_available_speakers()
    
    def validate_config(self) -> bool:
        """
        验证配置是否有效
        
        Returns:
            配置是否有效
        """
        if not self.client:
            return False
        
        return self.client.validate_config()
    
    def get_client_info(self) -> dict:
        """
        获取当前客户端信息
        
        Returns:
            客户端信息字典
        """
        return {
            'type': self.client_type,
            'class': self.client.__class__.__name__ if self.client else None,
            'is_valid': self.validate_config()
        }
    
    def switch_client(self, client_type: str):
        """
        切换 TTS 客户端类型
        
        Args:
            client_type: 新的客户端类型 ('http', 'websocket')
        """
        if client_type not in ['http', 'websocket']:
            raise ValueError(f"不支持的客户端类型: {client_type}")
        
        self.client_type = client_type
        self._initialize_client()
        print(f"🔄 已切换到 {client_type.upper()} TTS 客户端")


# 创建全局 TTS 管理器实例
tts_manager = TTSManager()


def get_tts_client() -> TTSManager:
    """
    获取全局 TTS 管理器实例
    
    Returns:
        TTS 管理器实例
    """
    return tts_manager


if __name__ == "__main__":
    # 测试代码
    import asyncio
    
    async def test():
        manager = TTSManager()
        print(f"当前客户端信息: {manager.get_client_info()}")
        
        try:
            # 测试同步合成
            audio_data = manager.synthesize("这是 TTS 管理器测试。")
            print(f"同步合成成功，音频数据长度: {len(audio_data)} 字节")
            
            # 测试异步合成
            audio_data = await manager.synthesize_async("这是异步合成测试。")
            print(f"异步合成成功，音频数据长度: {len(audio_data)} 字节")
            
        except Exception as e:
            print(f"测试失败: {e}")
    
    asyncio.run(test())